One reason plastics are used so often is that they’re chemically inert, meaning bags, food containers, and cups don't react with what we put in them. Yet they can still break down into microplastics, which turn up in drinking water, human blood, arteries, and brains. The consequences of that are uncertain.

“Whether microplastics can directly cause human disease is still being researched,” said Wei Min, a chemist at Columbia University. In a new Nature study, Min's team took a step toward answering this question by demonstrating that microplastics are likely not as chemically inert as we might expect.

Microdroplet chemistry

Min's lab has spent years working on microdroplet chemistry, studying how water broken into tiny droplets behaves at its boundary with air. These droplets have been reported to generate reactive oxygen species, or ROS, a family of harmful, oxygen-containing molecules. “ROS will essentially bump into proteins, lipids, DNA, and cause damage,” Min said. “You could break a DNA strand into segments. You could mutate DNA; you could misfold proteins.”

Many animal studies have tied microplastic toxicity to oxidative stress, which is caused by ROS. So the team wondered if the boundary between water and plastic might do something similar. “We got inspired by that field,” Min said.

In the first test, the team stirred polystyrene powder into water containing methyl orange, a yellow dye that ROS break apart. Over 10 days, the solution faded almost to colorless, losing nearly 90 percent of the dye. In ethanol or other solvents, the dye stayed intact. Min and his colleagues concluded that whatever chemistry polystyrene was undergoing needed water to happen. So they ran more tests.

Water under stress

First was electron spin resonance, a technique that directly detects radicals—atoms or molecules with an unpaired electron that makes them particularly reactive. The polystyrene powder and water mixture contained hydroxyl radicals, a highly reactive ROS.

Next, the team used a fluorescent sensor that lights up only when it reacts with hydroxyl radicals. “You don't see it, but once it reacts with local ROS, it turns into a bright color,” Min said. Under a microscope, the glow concentrated on the surfaces of the plastic particles and kept building over time.

The effect was not unique to polystyrene either. Scientists tested six common plastics—polyethylene, polypropylene, polystyrene, PVC, PET, and acrylic—and all of them generated radicals. The most water-repellent plastics, polyethylene and polypropylene, were the most active, while PET and acrylic, which contain chemical groups that attract water, were the least.

“The simplest answer is the most water-repellent ones change the water structure the most,” Min said. In ordinary, or bulk, water, each molecule is held in a network of hydrogen bonds with its neighbors. But a few layers of water molecules pressed against a water-repellent surface lose some of those partners. “Their structure is no longer the regular water structure. They are perturbed, and their energy is also significantly increased,” Min said.

Water always contains a small number of hydroxide ions, and turning one into a hydroxyl radical requires stripping away an electron. In bulk water, that costs a lot of energy. But simulations run by the group showed that, at a polyethylene surface, hydroxide ions short on hydrogen bonds needed far less energy to form radicals. On top of that, the plastic surfaces build up a negative electric charge in water, which further lowered the energy cost.

But Min’s team still had doubts to address before making any conclusive claims.

Ruling out the dirt

Min’s earlier work on microdroplet chemistry has drawn a lot of criticism, with some researchers arguing that the reported reactive chemicals come from contamination or measurement artifacts.

To avoid similar objections, Min and his colleagues used several independent detection methods. They also added a detergent-like surfactant that coats the plastic and disrupts the water layer at its surface. They found that the more surfactant they added, the weaker the plastic's electric charge became and the fewer radicals it produced. “We only change one parameter while keeping all the rest [the same],” Min said. “We're using exactly the same plastics, the same water, the same everything.”

Impurities, Min explained, are typically stable molecules with no reason to spontaneously generate radicals. He is careful not to overstate it, though. “To be absolutely clear, we cannot 100 percent rule out the involvement of impurities,” he said. “But our controls and our theoretical computation studies highly suggest that this is intrinsic to the microplastic-water interface.”

Finally, the team tested if this interface chemistry matters for biological molecules. And it most likely does.

Proteins and blood cells

Proteins and DNA can gather on plastic surfaces, and lysozyme, a common test protein, also began clumping into aggregates there. Adding caffeine, which mops up radicals, largely stopped the clumping, pointing to the radicals as the cause.

Mouse red blood cells that touched polystyrene particles broke into fragments, and the damage from each type of plastic tracked how many radicals it produced. The effect also persisted in blood serum.

Min stressed, though, that this indicates that microplastics make people sick by generating ROS. While animal studies often point to ROS as possible roots of oxidative stress and chronic inflammation, ROS can be produced in many ways, including through basic metabolic activity.

Min admitted comparing the magnitude of this effect to the impact of ROS our own cells make is rather tricky.

A local problem

“If you are really at the interface, you could be significantly affected by this effect, whereas if you are just a few microns away, you don't feel it anymore," Min said. Exposure is another unknown here. Min also emphasized that no one can yet say how many microplastics an average person takes in each year from food, water, and air.

The plastics in the study were mostly fresh, lab-bought powders, unlike weathered particles we encounter in the environment. In the team's tests, older particles with more oxidized surfaces produced somewhat weaker signals. “This aging process is very heterogeneous,” Min said. “Some microplastic particles were made 50 years ago, some were made five days ago.” Finally, there is the question of size.

Microplastics are usually defined as particles smaller than five millimeters, while the minimum cutoff varies between 100 and 1,000 nanometers. Min’s team did not test how variation in microplastic particle size affects water-interface chemistry, but the researchers suspect it might play a role. The same mass of plastic broken into nanoparticles has far more surface area, which might make the effect larger. "This may be another reason for nanoplastics to be more dangerous," Min said.

The researchers argue that if water-repellent surfaces drive the water interface chemistry, plastics could be designed to be less water-repellent, either by changing their molecular structure or including additives. First, though, the team wants to focus on the question their study left open. “We definitely want to see how much this effect is directly contributing to disease or biological problems in animals and humans,” Min said.

Nature, 2026. DOI: 10.1038/s41586-026-11141-y

Read full article

Comments

The collaborative reverse-engineering site decomp.dev is shutting down, with its administrator saying AI has made game decompilation so fast and accessible that the community's human-driven model has effectively broken down. "The administrator of the website said that it has become impossible to keep track of which projects are primarily human-led and which ones are done by AI," reports 404 Media. From the report: "Historically, matching decompilation has been a brutally difficult, time consuming task, on the scale of years for any moderately-sized game with a number of active contributors," the pseudonymous admin of decomp.dev, who goes by Encounter, wrote on the site. But recent frontier AI models like GPT-6-Astra have made it trivially easy to decompile a game: "They are significantly better at following complex directions, cross-referencing resources for symbols or debug information, and writing natural code with enough guidance," Encounter wrote. "It is now clear that, with the right guidance, human input, and code reviews, AI can expedite the decompilation process in a significant way. What is also now clear is that the community aspect of decompilation has been broken."

Read more of this story at Slashdot.

An anonymous reader quotes a report from Scientific American: Microplastics are a source of extreme concern for health: the presence of these tiny pieces of plastic has been linked to heart attacks, stroke, dementia and brain tumors. But what drives these associations is unclear. Now a study published in Nature offers a tantalizing clue: microplastics interact with water, generating highly reactive molecules. When microplastics come into contact with water, the water near their surface can become chemically active, generating highly reactive species that can modify nearby substances, including biologically important molecules. As plastics wear down to microscopic sizes, their surface-to-volume ratio increases dramatically. For example, when a credit card is fragmented into particles some 10 microns in diameter, there is a more than 200-fold increase in its surface area, says Wei Min, a chemist at Columbia University and one of the senior authors of the study. As a result, any chemical activity is amplified. Min and his colleagues examined various microplastics -- including polystyrene, polyethylene, polyvinyl chloride, polypropylene and polyethylene terephthalate. Plastic surfaces are hydrophobic, meaning they repel water, Min says. Thus, water molecules cannot form the hydrogen bonds they maintain in liquid form. That changes molecular arrangements, and, in turn, the change influences the local electrical environment and chemical reactivity. The presumed chemical inertness of bulk plastics overlooks the toxicity of their fragmented microscale forms. "For microplastics, this is especially important because fragmentation creates enormous amounts of new surface area," Min says. In past research, microplastics have been shown to cause inflammation, oxidative stress and decreased mitochondrial activity. The new study provides a possible mechanism for this, showing that plastic-water interfaces can perturb proteins, cell membranes, and more. How this might contribute to damage in living tissues in humans is still unclear, Min says. "Ultimately, we hope to connect fundamental interfacial chemistry with quantitative measurements of biological effects, which would help us better understand potential health risks," he adds.

Read more of this story at Slashdot.

We continue our study of C++ futures with std::async.

The more complex case is the std::async. You give std::async a callable and optional parameters to pass to that callable, and you also specify how and when you want the callable to be invoked. You get two axes: Do you want it to be calculated immediately or on demand? Do you want the calculation to happen on the thread that requests the value or on its own thread?

Now, you’d think you could fill out the table like this:

	Immediate	On demand (“deferred”)
Same thread	Call now and save the value	Call when waited
New thread (“async”)	Start the thread now	Start the thread when waited

However, that’s not what the C++ standard says.

The C++ standard disallows asking for an immediate value on the same thread. There’s really no value to doing it that way, since there is no actual “future”; it all happens in the present! “This future could have been a function call.”

auto f = std::async({}, calculator);

auto result = f.get();

This would, in theory, mean “Immediately call the calculator and wait for it to produce a value. Store it in the source and return a future that fetches the value from that source.” But that’s the same as just

auto result = calculator();

I’m guessing that the C++ standard disallows it because there’s no point.

The C++ standard also says that if you combine both std::launch::deferred and std::launch::async, it doesn’t mean that you get a calculation that lazy-starts on its own thread. Instead, the standard says that the implementation can choose which flag to honor and which to ignore.

So really, the table is

	Immediate	On demand (“deferred”)
Same thread	Illegal	Call when waited
New thread (“async”)	Start the thread now	Dealer’s choice

In all cases, the result of the callable (either a value or an exception) is stored in the source.

Now, I noted that there’s no point to asking std::async for an immediate on-thread calculation. But maybe you want to do it anyway because you are interfacing with some other component that expects to receive a future. How could you get the same result?

We’ll look at that next time.

The post C++ futures part 3: The mental model for <CODE>std::async</CODE> appeared first on The Old New Thing.

Last time, we looked at the “state” that powers the std::promise, std::packaged_task, std::async, std::future, and std::sharedfuture classes. Now we’ll see how that “state” (which I call the source) gets used and passed around.

The lifetime of the source is managed by a std::shared_ptr<source<T>>. Everybody who has a reference to the source uses this shared pointer.

The simplest case is std::promise. The operations on std::promise pretty much map directly to the operations on the source we laid out last time.

The next more complicated case is the std::packaged_task. This takes a callable and saves it for later. You can then call get_future to get a future and hand it to somebody as an IOU for “A value will appear here someday.”

When you want to produce a value, you invoke the packaged_task with whatever parameters you want to pass to the original callable. The result of the invocation (either a value or an exception) is then stored in the source object, which can then be retrieved by the future.

You can imagine a packaged task as just wrapping a promise:

template<typename R, typename... Args>
class packaged_task
{
    std::promise<R> p;
    std::function<R(Args...)> func;

public:
    template<typename F>
    packaged_task(F&& f) : func(std::forward<F>(f)) {}

    auto get_future() { return p.get_future(); }

    void operator()(Args... args) {
        try {
            p.set_value(func(args...));
        } catch (...) {
            p.set_exception(std::current_exception());
        }
    }
};

When you invoke it, it calls the stored callable with the arguments and puts the result in the promise.

Okay, those were the easy cases of pushing values into the source. Next time, we’ll look at the messy case: std::async.

The post C++ futures part 2: The mental model for <CODE>std::promise</CODE>, <CODE>std::packaged_task</CODE> appeared first on The Old New Thing.

Wrapping up our quick introduction to the C++ futures library, we come to the last two parts: std::future and std::shared_future.

The std::future is the starting point. It is a move-only class that this takes the source and forwards its wait and wait_for methods to the source, and forwards its get method to consume.

Forwarding the get to consume means that you can call get only once.

The idea is that std::future is for the case where there is exactly one consumer of the value. Since it is move-only, you can’t copy it; you can only give it away and transfer the power to retrieve the value to the recipient.

The std::future has a method called shared(). This transfers the source from the future to a shared_future object. The shared_future also forwards its wait and wait_for methods to the source, but instead of forwarding its get to the source::consume, shared_future::get() just calls source::get to get a reference to the value storage.

This is what makes the “shared future” shared: The shared_future is copyable, so you can have multiple people all with their own shared_future that share the same source, and each one can separately wait for the value and retrieve the value as many times as they want.

The downside of shared_future is that you always get a const reference, so if you want to perform non-const operations on the result, you’ll have to make a copy and operate on the copy. And that’s not possible at all if the result is itself a move-only type, since you can’t move out of a const reference.

You can see that at the end of the day, all of the pieces of the futures library are just different ways of manipulating the invisible source. Some components push values into the source, and others pull values out of the source.

It took me a while to realize that the most important part of the whole futures library is something you can’t even see.

Bonus chatter: All the names in the futures library are horrible. I mean, really, “packaged task”?

Here’s my attempt to give the pieces better names:

Old name	New name
promise	promise_source
packaged_task	function_promise_source
async(deferred)	make_lazy_promise
async(async)	make_thread_promise
future	promise
shared_future	shared_promise

I admit, these names aren’t all that good either. But I prefer to use the word “promise” to refer to the thing that “promises” to produce a value. And the pattern promise_source / promise makes the relationship between the two much clearer: A promise source is a thing that makes promises. And it avoids the hilarity of a non-async async().

The post C++ futures part 5: <CODE>std::<WBR>future</CODE> and <CODE>std::<WBR>shared_future</CODE> appeared first on The Old New Thing.